home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 10 / AACD 10.iso / AACD / Programming / MiniGL / demos / gears.c < prev    next >
Encoding:
C/C++ Source or Header  |  2000-04-07  |  13.2 KB  |  676 lines
  1. #include <stdlib.h>
  2. #include <mgl/gl.h>
  3.  
  4. #include <math.h>
  5. /* Some <math.h> files do not define M_PI... */
  6. #ifndef M_PI
  7. #define M_PI 3.14159265
  8. #endif
  9. #include <stdio.h>
  10.  
  11. /* For portability... */
  12. #undef fcos
  13. #undef fsin
  14. #undef fsqrt
  15. #define fcos  cos
  16. #define fsin  sin
  17. #define fsqrt sqrt
  18.  
  19. static double d_near = 1.0;
  20. static double d_far = 2000;
  21. static int poo = 0;
  22.  
  23. int show = 1;
  24.  
  25. typedef struct {
  26.   float rad, wid;
  27. } Profile;
  28.  
  29. void flat_face(float ir, float or, float wd);
  30. void draw_inside(float w1, float w2, float rad);
  31. void draw_outside(float w1, float w2, float rad);
  32. void tooth_side(int nt, float ir, float or, float tp, float tip, float wd);
  33.  
  34. int circle_subdiv;
  35. #define MIN_SUBDIV 30
  36.  
  37. GLboolean bEnvMap = GL_TRUE;
  38.  
  39. GLubyte *LoadPPM(char *name, GLint *w, GLint *h)
  40. {
  41.     int i;
  42.     unsigned long x,y;
  43.     FILE *f;
  44.     GLubyte *where;
  45.  
  46.     f = fopen(name, "r");
  47.  
  48.     if (!f)
  49.     {
  50.         *w = 0; *h=0;
  51.         return NULL;
  52.     }
  53.     #ifndef __STORM__
  54.     i = fscanf(f, "P6\n%ld %ld\n255\n",&x, &y);
  55.     #else
  56.     i = fscanf(f, "P6\n%ld\n%ld\n255\n", &x, &y);
  57.     #endif
  58.  
  59.     if (i!= 2)
  60.     {
  61.         printf("Error scanning PPM header\n");
  62.         fclose(f);
  63.         *w = 0; *h = 0;
  64.         return NULL;
  65.     }
  66.  
  67.     *w = x;
  68.     *h = y;
  69.  
  70.     where = malloc(x*y*3);
  71.     if (!where)
  72.     {
  73.         printf("Error out of Memory\n");
  74.         fclose(f);
  75.         *w = 0; *h = 0;
  76.         return NULL;
  77.     }
  78.  
  79.     i = fread(where, 1, x*y*3, f);
  80.     fclose(f);
  81.  
  82.     if (i != x*y*3)
  83.     {
  84.         printf("Error while reading file\n");
  85.         free(where);
  86.         *w = 0; *h = 0;
  87.         return NULL;
  88.     }
  89.  
  90.     return where;
  91. }
  92.  
  93.  
  94. BOOL TexInit(char *name)
  95. {
  96.     GLubyte *tmap;
  97.     GLint x,y;
  98.  
  99.     glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
  100.     glPixelStorei(GL_PACK_ALIGNMENT, 1);
  101.  
  102.     if (!name)
  103.     {
  104.         tmap = LoadPPM("data/chrome.ppm",&x, &y);
  105.     }
  106.     else
  107.     {
  108.         tmap = LoadPPM(name, &x, &y);
  109.     }
  110.  
  111.     if (!tmap)
  112.         return FALSE;
  113.  
  114.     glBindTexture(GL_TEXTURE_2D, 1);
  115.     glTexImage2D(GL_TEXTURE_2D, 0, 3,
  116.         x,y, 0, GL_RGB, GL_UNSIGNED_BYTE, tmap);
  117.     free(tmap);
  118.  
  119.     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
  120.     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
  121.  
  122.     glEnable(GL_TEXTURE_2D);
  123.     glEnable(GL_TEXTURE_GEN_S);
  124.     glEnable(GL_TEXTURE_GEN_T);
  125.     glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_SPHERE_MAP);
  126.     glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_SPHERE_MAP);
  127.  
  128.     return TRUE;
  129. }
  130.  
  131.  
  132.  
  133. void
  134. gear(int nt, float wd, float ir, float or, float tp, float tip, int ns, Profile * ip)
  135. {
  136.   /**
  137.    * nt - number of teeth 
  138.    * wd - width of gear at teeth
  139.    * ir - inside radius absolute scale
  140.    * or - radius at outside of wheel (tip of tooth) ratio of ir
  141.    * tp - ratio of tooth in slice of circle (0..1] (1 = teeth are touching at base)
  142.    * tip - ratio of tip of tooth (0..tp] (cant be wider that base of tooth)
  143.    * ns - number of elements in wheel width profile
  144.    * *ip - list of float pairs {start radius, width, ...} (width is ratio to wd)
  145.    *
  146.    */
  147.  
  148.   /* gear lying on xy plane, z for width. all normals calulated 
  149.      (normalized) */
  150.  
  151.   float prev;
  152.   int k, t;
  153.  
  154.   /* estimat # times to divide circle */
  155.   if (nt <= 0)
  156.     circle_subdiv = MIN_SUBDIV;
  157.   else {
  158.     /* lowest multiple of number of teeth */
  159.     circle_subdiv = nt;
  160.     while (circle_subdiv < MIN_SUBDIV)
  161.       circle_subdiv += nt;
  162.   }
  163.  
  164.   /* --- draw wheel face --- */
  165.  
  166.   /* draw horzontal, vertical faces for each section. if first
  167.      section radius not zero, use wd for 0.. first if ns == 0
  168.      use wd for whole face. last width used to edge.  */
  169.  
  170.   if (ns <= 0) {
  171.     flat_face(0.0, ir, wd);
  172.   } else {
  173.     /* draw first flat_face, then continue in loop */
  174.     if (ip[0].rad > 0.0) {
  175.       flat_face(0.0, ip[0].rad * ir, wd);
  176.       prev = wd;
  177.       t = 0;
  178.     } else {
  179.       flat_face(0.0, ip[1].rad * ir, ip[0].wid * wd);
  180.       prev = ip[0].wid;
  181.       t = 1;
  182.     }
  183.     for (k = t; k < ns; k++) {
  184.       if (prev < ip[k].wid) {
  185.         draw_inside(prev * wd, ip[k].wid * wd, ip[k].rad * ir);
  186.       } else {
  187.         draw_outside(prev * wd, ip[k].wid * wd, ip[k].rad * ir);
  188.       }
  189.       prev = ip[k].wid;
  190.       /* - draw to edge of wheel, add final face if needed - */
  191.       if (k == ns - 1) {
  192.         flat_face(ip[k].rad * ir, ir, ip[k].wid * wd);
  193.  
  194.         /* now draw side to match tooth rim */
  195.         if (ip[k].wid < 1.0) {
  196.           draw_inside(ip[k].wid * wd, wd, ir);
  197.         } else {
  198.           draw_outside(ip[k].wid * wd, wd, ir);
  199.         }
  200.       } else {
  201.         flat_face(ip[k].rad * ir, ip[k + 1].rad * ir, ip[k].wid * wd);
  202.       }
  203.     }
  204.   }
  205.  
  206.   /* --- tooth side faces --- */
  207.   tooth_side(nt, ir, or, tp, tip, wd);
  208.  
  209.   /* --- tooth hill surface --- */
  210. }
  211.  
  212. void 
  213. tooth_side(int nt, float ir, float or, float tp, float tip, float wd)
  214. {
  215.  
  216.   float i;
  217.   float end = 2.0 * M_PI / nt;
  218.   float x[6], y[6];
  219.   float s[3], c[3];
  220.  
  221.   or = or * ir;         /* or is really a ratio of ir */
  222.   for (i = 0; i < 2.0 * M_PI - end / 4.0; i += end) {
  223.  
  224.     c[0] = fcos(i);
  225.     s[0] = fsin(i);
  226.     c[1] = fcos(i + end * (0.5 - tip / 2));
  227.     s[1] = fsin(i + end * (0.5 - tip / 2));
  228.     c[2] = fcos(i + end * (0.5 + tp / 2));
  229.     s[2] = fsin(i + end * (0.5 + tp / 2));
  230.  
  231.     x[0] = ir * c[0];
  232.     y[0] = ir * s[0];
  233.     x[5] = ir * fcos(i + end);
  234.     y[5] = ir * fsin(i + end);
  235.     /* ---treat veritices 1,4 special to match strait edge of
  236.        face */
  237.     x[1] = x[0] + (x[5] - x[0]) * (0.5 - tp / 2);
  238.     y[1] = y[0] + (y[5] - y[0]) * (0.5 - tp / 2);
  239.     x[4] = x[0] + (x[5] - x[0]) * (0.5 + tp / 2);
  240.     y[4] = y[0] + (y[5] - y[0]) * (0.5 + tp / 2);
  241.     x[2] = or * fcos(i + end * (0.5 - tip / 2));
  242.     y[2] = or * fsin(i + end * (0.5 - tip / 2));
  243.     x[3] = or * fcos(i + end * (0.5 + tip / 2));
  244.     y[3] = or * fsin(i + end * (0.5 + tip / 2));
  245.  
  246.     /* draw face trapezoids as 2 tmesh */
  247.     glNormal3f(0.0, 0.0, 1.0);
  248.     glBegin(GL_TRIANGLE_STRIP);
  249.     glVertex3f(x[2], y[2], wd / 2);
  250.     glVertex3f(x[1], y[1], wd / 2);
  251.     glVertex3f(x[3], y[3], wd / 2);
  252.     glVertex3f(x[4], y[4], wd / 2);
  253.     glEnd();
  254.  
  255.     glNormal3f(0.0, 0.0, -1.0);
  256.     glBegin(GL_TRIANGLE_STRIP);
  257.     glVertex3f(x[2], y[2], -wd / 2);
  258.     glVertex3f(x[1], y[1], -wd / 2);
  259.     glVertex3f(x[3], y[3], -wd / 2);
  260.     glVertex3f(x[4], y[4], -wd / 2);
  261.     glEnd();
  262.  
  263.     /* draw inside rim pieces */
  264.     glNormal3f(c[0], s[0], 0.0);
  265.     glBegin(GL_TRIANGLE_STRIP);
  266.     glVertex3f(x[0], y[0], -wd / 2);
  267.     glVertex3f(x[1], y[1], -wd / 2);
  268.     glVertex3f(x[0], y[0], wd / 2);
  269.     glVertex3f(x[1], y[1], wd / 2);
  270.     glEnd();
  271.  
  272.     /* draw up hill side */
  273.     {
  274.       float a, b, n;
  275.       /* calculate normal of face */
  276.       a = x[2] - x[1];
  277.       b = y[2] - y[1];
  278.       n = 1.0 / fsqrt(a * a + b * b);
  279.       a = a * n;
  280.       b = b * n;
  281.       glNormal3f(b, -a, 0.0);
  282.     }
  283.     glBegin(GL_TRIANGLE_STRIP);
  284.     glVertex3f(x[1], y[1], -wd / 2);
  285.     glVertex3f(x[2], y[2], -wd / 2);
  286.     glVertex3f(x[1], y[1], wd / 2);
  287.     glVertex3f(x[2], y[2], wd / 2);
  288.     glEnd();
  289.     /* draw top of hill */
  290.     glNormal3f(c[1], s[1], 0.0);
  291.     glBegin(GL_TRIANGLE_STRIP);
  292.     glVertex3f(x[2], y[2], -wd / 2);
  293.     glVertex3f(x[3], y[3], -wd / 2);
  294.     glVertex3f(x[2], y[2], wd / 2);
  295.     glVertex3f(x[3], y[3], wd / 2);
  296.     glEnd();
  297.  
  298.     /* draw down hill side */
  299.     {
  300.       float a, b, c;
  301.       /* calculate normal of face */
  302.       a = x[4] - x[3];
  303.       b = y[4] - y[3];
  304.       c = 1.0 / fsqrt(a * a + b * b);
  305.       a = a * c;
  306.       b = b * c;
  307.       glNormal3f(b, -a, 0.0);
  308.     }
  309.     glBegin(GL_TRIANGLE_STRIP);
  310.     glVertex3f(x[3], y[3], -wd / 2);
  311.     glVertex3f(x[4], y[4], -wd / 2);
  312.     glVertex3f(x[3], y[3], wd / 2);
  313.     glVertex3f(x[4], y[4], wd / 2);
  314.     glEnd();
  315.     /* inside rim part */
  316.     glNormal3f(c[2], s[2], 0.0);
  317.     glBegin(GL_TRIANGLE_STRIP);
  318.     glVertex3f(x[4], y[4], -wd / 2);
  319.     glVertex3f(x[5], y[5], -wd / 2);
  320.     glVertex3f(x[4], y[4], wd / 2);
  321.     glVertex3f(x[5], y[5], wd / 2);
  322.     glEnd();
  323.   }
  324. }
  325.  
  326. void 
  327. flat_face(float ir, float or, float wd)
  328. {
  329.  
  330.   int i;
  331.   float w;
  332.  
  333.   /* draw each face (top & bottom ) * */
  334.   if (poo)
  335.     printf("Face  : %f..%f wid=%f\n", ir, or, wd);
  336.   if (wd == 0.0)
  337.     return;
  338.   for (w = wd / 2; w > -wd; w -= wd) {
  339.     if (w > 0.0)
  340.       glNormal3f(0.0, 0.0, 1.0);
  341.     else
  342.       glNormal3f(0.0, 0.0, -1.0);
  343.  
  344.     if (ir == 0.0) {
  345.       /* draw as t-fan */
  346.       glBegin(GL_TRIANGLE_FAN);
  347.       glVertex3f(0.0, 0.0, w);  /* center */
  348.       glVertex3f(or, 0.0, w);
  349.       for (i = 1; i < circle_subdiv; i++) {
  350.         glVertex3f(fcos(2.0 * M_PI * i / (float)circle_subdiv) * or,
  351.           fsin(2.0 * M_PI * i / (float)circle_subdiv) * or,
  352.           w);
  353.       }
  354.       glVertex3f(or, 0.0, w);
  355.       glEnd();
  356.     } else {
  357.       /* draw as tmesh */
  358.       glBegin(GL_TRIANGLE_STRIP);
  359.       glVertex3f(or, 0.0, w);
  360.       glVertex3f(ir, 0.0, w);
  361.       for (i = 1; i < circle_subdiv; i++) {
  362.         glVertex3f(fcos(2.0 * M_PI * i / (float)circle_subdiv) * or,
  363.           fsin(2.0 * M_PI * i / (float)circle_subdiv) * or,
  364.           w);
  365.         glVertex3f(fcos(2.0 * M_PI * i / (float)circle_subdiv) * ir,
  366.           fsin(2.0 * M_PI * i / (float)circle_subdiv) * ir,
  367.           w);
  368.       }
  369.       glVertex3f(or, 0.0, w);
  370.       glVertex3f(ir, 0.0, w);
  371.       glEnd();
  372.  
  373.     }
  374.   }
  375. }
  376.  
  377. void 
  378. draw_inside(float w1, float w2, float rad)
  379. {
  380.  
  381.   int i, j;
  382.   float c, s;
  383.   if (poo)
  384.     printf("Inside: wid=%f..%f rad=%f\n", w1, w2, rad);
  385.   if (w1 == w2)
  386.     return;
  387.  
  388.   w1 = w1 / 2;
  389.   w2 = w2 / 2;
  390.   for (j = 0; j < 2; j++) {
  391.     if (j == 1) {
  392.       w1 = -w1;
  393.       w2 = -w2;
  394.     }
  395.     glBegin(GL_TRIANGLE_STRIP);
  396.     glNormal3f(-1.0, 0.0, 0.0);
  397.     glVertex3f(rad, 0.0, w1);
  398.     glVertex3f(rad, 0.0, w2);
  399.     for (i = 1; i < circle_subdiv; i++) {
  400.       c = fcos(2.0 * M_PI * i / circle_subdiv);
  401.       s = fsin(2.0 * M_PI * i / circle_subdiv);
  402.       glNormal3f(-c, -s, 0.0);
  403.       glVertex3f(c * rad,
  404.         s * rad,
  405.         w1);
  406.       glVertex3f(c * rad,
  407.         s * rad,
  408.         w2);
  409.     }
  410.     glNormal3f(-1.0, 0.0, 0.0);
  411.     glVertex3f(rad, 0.0, w1);
  412.     glVertex3f(rad, 0.0, w2);
  413.     glEnd();
  414.   }
  415. }
  416.  
  417. void 
  418. draw_outside(float w1, float w2, float rad)
  419. {
  420.  
  421.   int i, j;
  422.   float c, s;
  423.   if (poo)
  424.     printf("Outsid: wid=%f..%f rad=%f\n", w1, w2, rad);
  425.   if (w1 == w2)
  426.     return;
  427.  
  428.   w1 = w1 / 2;
  429.   w2 = w2 / 2;
  430.   for (j = 0; j < 2; j++) {
  431.     if (j == 1) {
  432.       w1 = -w1;
  433.       w2 = -w2;
  434.     }
  435.     glBegin(GL_TRIANGLE_STRIP);
  436.     glNormal3f(1.0, 0.0, 0.0);
  437.     glVertex3f(rad, 0.0, w1);
  438.     glVertex3f(rad, 0.0, w2);
  439.     for (i = 1; i < circle_subdiv; i++) {
  440.       c = fcos(2.0 * M_PI * i / circle_subdiv);
  441.       s = fsin(2.0 * M_PI * i / circle_subdiv);
  442.       glNormal3f(c, s, 0.0);
  443.       glVertex3f(c * rad,
  444.         s * rad,
  445.         w1);
  446.       glVertex3f(c * rad,
  447.         s * rad,
  448.         w2);
  449.     }
  450.     glNormal3f(1.0, 0.0, 0.0);
  451.     glVertex3f(rad, 0.0, w1);
  452.     glVertex3f(rad, 0.0, w2);
  453.     glEnd();
  454.   }
  455. }
  456.  
  457. Profile gear_profile[] =
  458. {0.000, 0.0,
  459.   0.300, 7.0,
  460.   0.340, 0.4,
  461.   0.550, 0.64,
  462.   0.600, 0.4,
  463.   0.950, 1.0
  464. };
  465.  
  466. float a1 = 27.0;
  467. float a2 = 67.0;
  468. float a3 = 47.0;
  469. float a4 = 87.0;
  470. float i1 = 1.2;
  471. float i2 = 3.1;
  472. float i3 = 2.3;
  473. float i4 = 1.1;
  474.  
  475. void
  476. oneFrame(void)
  477. {
  478.   mglLockDisplay();
  479.   glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
  480.  
  481.   if (show & 1)
  482.   {
  483.     glPushMatrix();
  484.     glTranslatef(0.0, 0.0, -4.0);
  485.     glRotatef(a3, 1.0, 1.0, 1.0);
  486.     glRotatef(a4, 0.0, 0.0, -1.0);
  487.     glTranslatef(0.14, 0.2, 0.0);
  488.     glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
  489.     gear(40,
  490.         0.4, 2.0, 1.1,
  491.         0.8, 0.4,
  492.         sizeof(gear_profile) / sizeof(Profile), gear_profile);
  493.     glPopMatrix();
  494.   }
  495.  
  496.   if (show & 2)
  497.   {
  498.     glPushMatrix();
  499.     glTranslatef(0.1, 0.2, -3.8);
  500.     glRotatef(a2, -4.0, 2.0, -1.0);
  501.     glRotatef(a1, 1.0, -3.0, 1.0);
  502.     glTranslatef(0.0, -0.2, 0.0);
  503.     glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
  504.     glColor3f(1.0, 0.8, 0.0);
  505.     gear(36,
  506.         0.4, 2.0, 1.1,
  507.         0.7, 0.2,
  508.         sizeof(gear_profile) / sizeof(Profile), gear_profile);
  509.     glPopMatrix();
  510.   }
  511.  
  512.   a1 += i1;
  513.   if (a1 > 360.0)
  514.     a1 -= 360.0;
  515.   if (a1 < 0.0)
  516.     a1 -= 360.0;
  517.   a2 += i2;
  518.   if (a2 > 360.0)
  519.     a2 -= 360.0;
  520.   if (a2 < 0.0)
  521.     a2 -= 360.0;
  522.   a3 += i3;
  523.   if (a3 > 360.0)
  524.     a3 -= 360.0;
  525.   if (a3 < 0.0)
  526.     a3 -= 360.0;
  527.   a4 += i4;
  528.   if (a4 > 360.0)
  529.     a4 -= 360.0;
  530.   if (a4 < 0.0)
  531.     a4 -= 360.0;
  532.   mglSwitchDisplay();
  533. }
  534.  
  535. void
  536. display(void)
  537. {
  538.   glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
  539. }
  540.  
  541. void
  542. myReshape(int w, int h)
  543. {
  544.   glViewport(0, 0, w, h);
  545.   glMatrixMode(GL_PROJECTION);
  546.   glLoadIdentity();
  547.   glFrustum(-1.0, 1.0, -1.0, 1.0, d_near, d_far);
  548.   /**
  549.     use perspective instead:
  550.  
  551.     if (w <= h){
  552.         glOrtho( 0.0, 1.0,
  553.                  0.0, 1.0 * (GLfloat) h / (GLfloat) w,
  554.                 -16.0, 4.0);
  555.     }else{
  556.         glOrtho( 0.0, 1.0 * (GLfloat) w / (GLfloat) h,
  557.                  0.0, 1.0,
  558.                 -16.0, 4.0);
  559.     }
  560.    */
  561.   glMatrixMode(GL_MODELVIEW);
  562.   glLoadIdentity();
  563.   glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
  564. }
  565.  
  566.  
  567. void
  568. myinit(int w, int h)
  569. {
  570.   float f[20];
  571.   glClearColor(0.0, 0.0, 0.0, 0.0);
  572.   myReshape(w, h);
  573.   /* glShadeModel(GL_FLAT); */
  574.   glEnable(GL_DEPTH_TEST);
  575.   glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
  576.  
  577. }
  578.  
  579. /* ARGSUSED1 */
  580. void
  581. keys(char c)
  582. {
  583.  
  584.   if (c == 0x1b)
  585.     mglExit();
  586.  
  587.   if (c == '1')
  588.     show = 1;
  589.  
  590.   if (c == '2')
  591.     show = 2;
  592.  
  593.   if (c == '3')
  594.     show = 3;
  595.  
  596.  
  597.   if (c == 'e')
  598.   {
  599.     if (bEnvMap == GL_TRUE)
  600.     {
  601.         bEnvMap = GL_FALSE;
  602.         glDisable(GL_TEXTURE_GEN_S);
  603.         glDisable(GL_TEXTURE_GEN_T);
  604.     }
  605.     else
  606.     {
  607.         bEnvMap = GL_TRUE;
  608.         glEnable(GL_TEXTURE_GEN_S);
  609.         glEnable(GL_TEXTURE_GEN_T);
  610.     }
  611.   }
  612. }
  613.  
  614. int main(int argc, char *argv[])
  615. {
  616.     GLint width=640; GLint height=480;
  617.     int i;
  618.     GLboolean culling = GL_FALSE;
  619.     char *name = 0;
  620.  
  621.     for (i=1; i<argc; i++)
  622.     {
  623.         if (0 == stricmp(argv[i], "-width"))
  624.         {
  625.             i++;
  626.             width = atoi(argv[i]);
  627.         }
  628.         if (0 == stricmp(argv[i], "-height"))
  629.         {
  630.             i++;
  631.             height = atoi(argv[i]);
  632.         }
  633.         if (0 == stricmp(argv[i], "-envmap"))
  634.         {
  635.             i++;
  636.             name = argv[i];
  637.         }
  638.         if (0 == stricmp(argv[i], "-window"))
  639.         {
  640.             mglChooseWindowMode(GL_TRUE);
  641.         }
  642.     }
  643.  
  644.     mglChooseVertexBufferSize(1000);
  645.     mglChooseNumberOfBuffers(3);
  646.     MGLInit();
  647.     mglCreateContext(0,0,width,height);
  648.     mglEnableSync(GL_FALSE);
  649.  
  650.     if ( TexInit(name) )
  651.     {
  652.         glClearColor(0.0, 0.0, 0.0, 1.0);
  653.         glColor3f(1.0, 0.0, 0.0);
  654.         glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
  655.  
  656.         glDisable(GL_CULL_FACE);
  657.         glHint(MGL_W_ONE_HINT, GL_FASTEST);
  658.  
  659.         myinit(width, height);
  660.  
  661.         mglLockMode(MGL_LOCK_MANUAL);
  662.         mglIdleFunc(oneFrame);
  663.         mglKeyFunc(keys);
  664.         mglMainLoop();
  665.     }
  666.     else
  667.     {
  668.         printf("Can't find texture %s\n", name);
  669.     }
  670.  
  671.     mglDeleteContext();
  672.     MGLTerm();
  673.     return 0;             /* ANSI C requires main to return int. */
  674. }
  675.  
  676.